package com.jl15988.chainlog.util;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.HashMap;
import java.util.Map;

/**
 * 反射工具
 *
 * @author Jalon
 * @since 2025/9/29 15:35
 **/
public class ReflectionUtil {

    /**
     * 通过方法全路径获取参数名
     *
     * @param fullMethodName 方法全路径，格式如：com.example.MyClass.myMethod
     * @return 参数名数组，如果获取失败则返回null
     */
    public static String[] getParameterNamesByMethodName(String fullMethodName) {
        try {
            // 分割类名和方法名
            int lastDotIndex = fullMethodName.lastIndexOf('.');
            if (lastDotIndex == -1) {
                throw new IllegalArgumentException("无效的方法全路径格式");
            }

            String className = fullMethodName.substring(0, lastDotIndex);
            String methodName = fullMethodName.substring(lastDotIndex + 1);

            // 加载类
            Class<?> clazz = Class.forName(className);

            // 处理构造方法（如果方法名是类名）
            if (methodName.equals(clazz.getSimpleName())) {
                for (Constructor<?> constructor : clazz.getConstructors()) {
                    // 这里简化处理，实际可能需要根据参数类型进一步匹配
                    Parameter[] parameters = constructor.getParameters();
                    String[] paramNames = new String[parameters.length];
                    for (int i = 0; i < parameters.length; i++) {
                        paramNames[i] = parameters[i].getName();
                    }
                    return paramNames;
                }
            }

            // 处理普通方法
            for (Method method : clazz.getMethods()) {
                if (method.getName().equals(methodName)) {
                    // 这里简化处理，实际可能需要根据参数类型进一步匹配重载方法
                    Parameter[] parameters = method.getParameters();
                    String[] paramNames = new String[parameters.length];
                    for (int i = 0; i < parameters.length; i++) {
                        paramNames[i] = parameters[i].getName();
                    }
                    return paramNames;
                }
            }

            // 如果没找到public方法，尝试查找所有方法（包括非public）
            for (Method method : clazz.getDeclaredMethods()) {
                if (method.getName().equals(methodName)) {
                    Parameter[] parameters = method.getParameters();
                    String[] paramNames = new String[parameters.length];
                    for (int i = 0; i < parameters.length; i++) {
                        paramNames[i] = parameters[i].getName();
                    }
                    return paramNames;
                }
            }

        } catch (ClassNotFoundException e) {
            System.err.println("类未找到: " + e.getMessage());
        } catch (Exception e) {
            System.err.println("获取参数名失败: " + e.getMessage());
        }
        return null;
    }

    public static Map<String, Object> formatMethodParams(String fullMethodName, Object... values) {
        String[] names = ReflectionUtil.getParameterNamesByMethodName(fullMethodName);
        if (names == null || names.length == 0) {
            return new HashMap<>();
        }
        Map<String, Object> params = new HashMap<>();
        for (int i = 0; i < names.length; i++) {
            params.put(names[i], values[i]);
        }
        return params;
    }
}
